Lets a client run N sequential invocation/command_execution requests over a
single WebSocket. Adds end_session_message (client -> server) and reworks the
Node session around per-request AbortController/ArtifactManager so cancel
aborts only the in-flight request.

Python: new RuntimeUseSession + RuntimeUseClient.session() context manager;
one-shot query()/execute_commands() preserved as convenience wrappers.

Bumps runtimeuse and runtimeuse-client to 0.11.0.

Post-agent command failures previously threw out of run(), causing the
session catch block to replace the successful agent result with an
error_message — the client would never see the actual result.

Now post-agent failures emit an error_message (so the client is notified)
but the agent's result_message is still returned as the terminal.

runCommands emitted error_message on non-zero exit and also threw, so pre-agent
failures produced one frame and post-agent failures produced two (both from
runCommands and from the subsequent catch block I added). Either way, the
error_message is terminal on the wire — the Python client raises on it and
never consumes result_message.

Now runCommands only throws; the session's outer catch emits a single
error_message for pre-agent failures, and post-agent failures are logged
server-side so result_message remains the sole terminal.

Wrap handleRequest's body in try/finally so requestInFlight, the abort
controller, and the artifact manager are always cleared. Previously, if
stopWatching / waitForPendingRequests / waitForAll threw (or were cancelled),
requestInFlight stayed true and every subsequent request was rejected with
"another is in flight", defeating the whole point of a persistent session.

Also swallow drain errors (log only) so a watcher failure can't abort the
terminal send.

Preserve the pre-refactor behavior: a failed post-agent command terminates
the request with error_message, so the Python client raises AgentRuntimeError.
runCommands still doesn't emit error_message itself — the session's outer
catch is the single wire emit point, so there's no double-emit.

Previously the watcher was torn down and recreated per request, which
forced each request to block on a 3s chokidar-drain window before the
terminal could be sent — so sequential calls on a persistent session were
spaced by the delay.

Now ArtifactManager lives for the whole session and exposes addDirectory()
so each request just registers its artifacts_dir with the existing watcher.
The drain (3s delay + stopWatching + waitForPendingRequests + waitForAll)
happens once, on session close, catching files written right before the
ws closed. Requests return as soon as the agent (and post-agent commands)
finish.

Also tightens mocks in session.test.ts (mockReset in beforeEach) and
covers the new behavior with "stops watcher on close, not per request"
and "registers each request's artifacts_dir on the shared watcher".

Additionally pulls in prior fixes in this branch:
- _run_request_loop drains the server's terminal before raising
  CancelledException, preventing stale error_messages from leaking into
  the next request on a persistent session.
- command-handler coerces non-numeric error.code (e.g. ABORT_ERR) to -1.
- session overrides terminal with "Request cancelled" when the runner
  returned a partial result after abort.